package gee

import (
	"fmt"
	"strings"
)

type node struct {
	pattern  string  // 待匹配路由，例如 /p/:lang
	part     string  // 路由中的一部分，例如 :lang
	children []*node // 子节点，例如 [doc, tutorial, intro]
	isWild   bool    // 是否精确匹配，part 含有 : 或 * 时为true
}

func (n *node) String() string {
	return fmt.Sprintf("node{pattern=%s, part=%s, isWild=%t}", n.pattern, n.part, n.isWild)
}

func (n *node) insert(pattern string, parts []string, height int) {
	if len(parts) == height {
		n.pattern = pattern
		return
	}

	part := parts[height]
	child := n.matchChild(part)
	if child == nil {
		child = &node{
			part:   part,
			isWild: part[0] == ':' || part[0] == '*',
		}
		n.children = append(n.children, child)
	}
	child.insert(pattern, parts, height+1)
}

// search 方法用于在路由树中查找与给定路径部分匹配的节点。
// 参数 parts 表示待匹配的路径部分的切片，height 表示当前匹配的深度。
func (n *node) search(parts []string, height int) *node {
	// 如果路径部分已经匹配完毕或当前节点的部分以 "*" 开头，则终止匹配并返回当前节点，或者如果当前节点没有模式，则返回 nil。
	if len(parts) == height || strings.HasPrefix(n.part, "*") {
		if n.pattern == "" {
			return nil
		}
		return n
	}

	part := parts[height]             // 获取当前路径部分。
	children := n.matchChildren(part) // 查找与当前部分匹配的子节点。

	// 遍历匹配的子节点。
	for _, child := range children {
		// 递归调用 search 方法继续匹配下一个路径部分。
		result := child.search(parts, height+1)
		// 如果找到匹配的节点，则返回结果。
		if result != nil {
			return result
		}
	}
	return nil // 如果没有找到匹配的节点，则返回 nil。
}

func (n *node) travel(list *[]*node) {
	if n.pattern != "" {
		*list = append(*list, n)
	}
	for _, child := range n.children {
		child.travel(list)
	}
}

func (n *node) matchChild(part string) *node {
	for _, child := range n.children {
		if child.part == part || child.isWild {
			return child
		}
	}
	return nil
}

func (n *node) matchChildren(part string) []*node {
	nodes := make([]*node, 0)
	for _, child := range n.children {
		if child.part == part || child.isWild {
			nodes = append(nodes, child)
		}
	}
	return nodes
}
